20 research outputs found
A General Theory of Sample Complexity for Multi-Item Profit Maximization
The design of profit-maximizing multi-item mechanisms is a notoriously
challenging problem with tremendous real-world impact. The mechanism designer's
goal is to field a mechanism with high expected profit on the distribution over
buyers' values. Unfortunately, if the set of mechanisms he optimizes over is
complex, a mechanism may have high empirical profit over a small set of samples
but low expected profit. This raises the question, how many samples are
sufficient to ensure that the empirically optimal mechanism is nearly optimal
in expectation? We uncover structure shared by a myriad of pricing, auction,
and lottery mechanisms that allows us to prove strong sample complexity bounds:
for any set of buyers' values, profit is a piecewise linear function of the
mechanism's parameters. We prove new bounds for mechanism classes not yet
studied in the sample-based mechanism design literature and match or improve
over the best known guarantees for many classes. The profit functions we study
are significantly different from well-understood functions in machine learning,
so our analysis requires a sharp understanding of the interplay between
mechanism parameters and buyer values. We strengthen our main results with
data-dependent bounds when the distribution over buyers' values is
"well-behaved." Finally, we investigate a fundamental tradeoff in sample-based
mechanism design: complex mechanisms often have higher profit than simple
mechanisms, but more samples are required to ensure that empirical and expected
profit are close. We provide techniques for optimizing this tradeoff
Learning to Optimize Computational Resources: Frugal Training with Generalization Guarantees
Algorithms typically come with tunable parameters that have a considerable
impact on the computational resources they consume. Too often, practitioners
must hand-tune the parameters, a tedious and error-prone task. A recent line of
research provides algorithms that return nearly-optimal parameters from within
a finite set. These algorithms can be used when the parameter space is infinite
by providing as input a random sample of parameters. This data-independent
discretization, however, might miss pockets of nearly-optimal parameters: prior
research has presented scenarios where the only viable parameters lie within an
arbitrarily small region. We provide an algorithm that learns a finite set of
promising parameters from within an infinite set. Our algorithm can help
compile a configuration portfolio, or it can be used to select the input to a
configuration algorithm for finite parameter spaces. Our approach applies to
any configuration problem that satisfies a simple yet ubiquitous structure: the
algorithm's performance is a piecewise constant function of its parameters.
Prior research has exhibited this structure in domains from integer programming
to clustering
Dispersion for Data-Driven Algorithm Design, Online Learning, and Private Optimization
Data-driven algorithm design, that is, choosing the best algorithm for a
specific application, is a crucial problem in modern data science.
Practitioners often optimize over a parameterized algorithm family, tuning
parameters based on problems from their domain. These procedures have
historically come with no guarantees, though a recent line of work studies
algorithm selection from a theoretical perspective. We advance the foundations
of this field in several directions: we analyze online algorithm selection,
where problems arrive one-by-one and the goal is to minimize regret, and
private algorithm selection, where the goal is to find good parameters over a
set of problems without revealing sensitive information contained therein. We
study important algorithm families, including SDP-rounding schemes for problems
formulated as integer quadratic programs, and greedy techniques for canonical
subset selection problems. In these cases, the algorithm's performance is a
volatile and piecewise Lipschitz function of its parameters, since tweaking the
parameters can completely change the algorithm's behavior. We give a sufficient
and general condition, dispersion, defining a family of piecewise Lipschitz
functions that can be optimized online and privately, which includes the
functions measuring the performance of the algorithms we study. Intuitively, a
set of piecewise Lipschitz functions is dispersed if no small region contains
many of the functions' discontinuities. We present general techniques for
online and private optimization of the sum of dispersed piecewise Lipschitz
functions. We improve over the best-known regret bounds for a variety of
problems, prove regret bounds for problems not previously studied, and give
matching lower bounds. We also give matching upper and lower bounds on the
utility loss due to privacy. Moreover, we uncover dispersion in auction design
and pricing problems
Sorting from Crowdsourced Comparisons using Expert Verifications
We introduce a novel noisy sorting model motivated by the Just Noticeable
Difference (JND) model from experimental psychology. The goal of our model is
to capture the low quality of the data that are collected from crowdsourcing
environments. Compared to other celebrated models of noisy sorting, our model
does not rely on precise data-generation assumptions and captures crowdsourced
tasks' varying levels of difficulty that can lead to different amounts of noise
in the data. To handle this challenging task, we assume we can verify some of
the collected data using expert advice. This verification procedure is costly;
hence, we aim to minimize the number of verifications we use.
We propose a new efficient algorithm called CandidateSort, which we prove
uses the optimal number of verifications in the noisy sorting models we
consider. We characterize this optimal number of verifications by showing that
it is linear in a parameter , which intuitively measures the maximum number
of comparisons that are wrong but not inconsistent in the crowdsourcing data
Synchronization Strings: Channel Simulations and Interactive Coding for Insertions and Deletions
We present many new results related to reliable (interactive) communication over insertion-deletion channels. Synchronization errors, such as insertions and deletions, strictly generalize the usual symbol corruption errors and are much harder to protect against.
We show how to hide the complications of synchronization errors in many applications by introducing very general channel simulations which efficiently transform an insertion-deletion channel into a regular symbol corruption channel with an error rate larger by a constant factor and a slightly smaller alphabet. We utilize and generalize synchronization string based methods which were recently introduced as a tool to design essentially optimal error correcting codes for insertion-deletion channels. Our channel simulations depend on the fact that, at the cost of increasing the error rate by a constant factor, synchronization strings can be decoded in a streaming manner that preserves linearity of time. Interestingly, we provide a lower bound showing that this constant factor cannot be improved to 1+epsilon, in contrast to what is achievable for error correcting codes. Our channel simulations drastically and cleanly generalize the applicability of synchronization strings.
We provide new interactive coding schemes which simulate any interactive two-party protocol over an insertion-deletion channel. Our results improve over the interactive coding schemes of Braverman et al. [TransInf `17] and Sherstov and Wu [FOCS `17] which achieve a small constant rate and require exponential time computations with respect to computational and communication complexities. We provide the first computationally efficient interactive coding schemes for synchronization errors, the first coding scheme with a rate approaching one for small noise rates, and also the first coding scheme that works over arbitrarily small alphabet sizes. We also show tight connections between synchronization strings and edit-distance tree codes which allow us to transfer results from tree codes directly to edit-distance tree codes.
Finally, using on our channel simulations, we provide an explicit low-rate binary insertion-deletion code that improves over the state-of-the-art codes by Guruswami and Wang [TransInf `17] in terms of rate-distance trade-off
Generalization in portfolio-based algorithm selection
Portfolio-based algorithm selection has seen tremendous practical success
over the past two decades. This algorithm configuration procedure works by
first selecting a portfolio of diverse algorithm parameter settings, and then,
on a given problem instance, using an algorithm selector to choose a parameter
setting from the portfolio with strong predicted performance. Oftentimes, both
the portfolio and the algorithm selector are chosen using a training set of
typical problem instances from the application domain at hand. In this paper,
we provide the first provable guarantees for portfolio-based algorithm
selection. We analyze how large the training set should be to ensure that the
resulting algorithm selector's average performance over the training set is
close to its future (expected) performance. This involves analyzing three key
reasons why these two quantities may diverge: 1) the learning-theoretic
complexity of the algorithm selector, 2) the size of the portfolio, and 3) the
learning-theoretic complexity of the algorithm's performance as a function of
its parameters. We introduce an end-to-end learning-theoretic analysis of the
portfolio construction and algorithm selection together. We prove that if the
portfolio is large, overfitting is inevitable, even with an extremely simple
algorithm selector. With experiments, we illustrate a tradeoff exposed by our
theoretical analysis: as we increase the portfolio size, we can hope to include
a well-suited parameter setting for every possible problem instance, but it
becomes impossible to avoid overfitting.Comment: AAAI 202